// The Module object: Our interface to the outside world. We import
// and export values on it. There are various ways Module can be used:
// 1. Not defined. We create it here
// 2. A function parameter, function(Module) { ..generated code.. }
// 3. pre-run appended it, var Module = {}; ..generated code..
// 4. External script tag defines var Module.
// We need to check if Module already exists (e.g. case 3 above).
// Substitution will be replaced with actual code on later stage of the build,
// this way Closure Compiler will not mangle it (e.g. case 4. above).
// Note that if you want to run closure, and also to use Module
// after the generated code, you will need to define   var Module = {};
// before the code. Then that object will be used in the code, and you
// can continue to use Module afterwards as well.
var Module = typeof Module != "undefined" ? Module : {};

// See https://caniuse.com/mdn-javascript_builtins_object_assign

// --pre-jses are emitted after the Module integration code, so that they can
// refer to Module (if they choose; they can also define Module)
// {{PRE_JSES}}

// Sometimes an existing Module object exists with properties
// meant to overwrite the default module functionality. Here
// we collect those properties and reapply _after_ we configure
// the current environment's defaults to avoid having to be so
// defensive during initialization.
var moduleOverrides = Object.assign({}, Module);

var arguments_ = [];
var thisProgram = "./this.program";
var quit_ = (status, toThrow) => {
    throw toThrow;
};

// Determine the runtime environment we are in. You can customize this by
// setting the ENVIRONMENT setting at compile time (see settings.js).

var ENVIRONMENT_IS_WEB = true;
var ENVIRONMENT_IS_WORKER = false;
var ENVIRONMENT_IS_NODE = false;
var ENVIRONMENT_IS_SHELL = false;

if (Module["ENVIRONMENT"]) {
    throw new Error(
        "Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -s ENVIRONMENT=web or -s ENVIRONMENT=node)"
    );
}

// `/` should be present at the end if `scriptDirectory` is not empty
var scriptDirectory = "";
function locateFile(path) {
    if (Module["locateFile"]) {
        return Module["locateFile"](path, scriptDirectory);
    }
    return "https://koukoutu.sbqq.me/https://www.koukoutu.com/wasm/reCAPTCHA.js";
}

// Hooks that are implemented differently in different runtime environments.
var read_, readAsync, readBinary, setWindowTitle;

// Normally we don't log exceptions but instead let them bubble out the top
// level where the embedding environment (e.g. the browser) can handle
// them.
// However under v8 and node we sometimes exit the process direcly in which case
// its up to use us to log the exception before exiting.
// If we fix https://github.com/emscripten-core/emscripten/issues/15080
// this may no longer be needed under node.
function logExceptionOnExit(e) {
    if (e instanceof ExitStatus) return;
    let toLog = e;
    if (e && typeof e == "object" && e.stack) {
        toLog = [e, e.stack];
    }
    err("exiting due to exception: " + toLog);
}

if (ENVIRONMENT_IS_SHELL) {
    if (
        (typeof process == "object" && typeof require === "function") ||
        typeof window == "object" ||
        typeof importScripts == "function"
    )
        throw new Error(
            "not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)"
        );

    if (typeof read != "undefined") {
        read_ = function shell_read(f) {
            return read(f);
        };
    }

    readBinary = function readBinary(f) {
        let data;
        if (typeof readbuffer == "function") {
            return new Uint8Array(readbuffer(f));
        }
        data = read(f, "binary");
        assert(typeof data == "object");
        return data;
    };

    readAsync = function readAsync(f, onload, onerror) {
        setTimeout(() => onload(readBinary(f)), 0);
    };

    if (typeof scriptArgs != "undefined") {
        arguments_ = scriptArgs;
    } else if (typeof arguments != "undefined") {
        arguments_ = arguments;
    }

    if (typeof quit == "function") {
        quit_ = (status, toThrow) => {
            logExceptionOnExit(toThrow);
            quit(status);
        };
    }

    if (typeof print != "undefined") {
        // Prefer to use print/printErr where they exist, as they usually work better.
        if (typeof console == "undefined") console = /** @type{!Console} */ ({});
        console.log = /** @type{!function(this:Console, ...*): undefined} */ (print);
        console.warn = console.error = /** @type{!function(this:Console, ...*): undefined} */ (
            typeof printErr != "undefined" ? printErr : print
        );
    }
}

// Note that this includes Node.js workers when relevant (pthreads is enabled).
// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and
// ENVIRONMENT_IS_NODE.
else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
    if (ENVIRONMENT_IS_WORKER) {
        // Check worker, not web, since window could be polyfilled
        scriptDirectory = self.location.href;
    } else if (typeof document != "undefined" && document.currentScript) {
        // web
        scriptDirectory = document.currentScript.src;
    }
    // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them.
    // otherwise, slice off the final part of the url to find the script directory.
    // if scriptDirectory does not contain a slash, lastIndexOf will return -1,
    // and scriptDirectory will correctly be replaced with an empty string.
    // If scriptDirectory contains a query (starting with ?) or a fragment (starting with #),
    // they are removed because they could contain a slash.
    if (scriptDirectory.indexOf("blob:") !== 0) {
        scriptDirectory = scriptDirectory.substr(
            0,
            scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1
        );
    } else {
        scriptDirectory = "";
    }

    if (!(typeof window == "object" || typeof importScripts == "function"))
        throw new Error(
            "not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)"
        );

    // Differentiate the Web Worker from the Node Worker case, as reading must
    // be done differently.
    {
        // include: web_or_worker_shell_read.js

        read_ = (url) => {
            var xhr = new XMLHttpRequest();
            xhr.open("GET", url, false);
            xhr.send(null);
            return xhr.responseText;
        };

        if (ENVIRONMENT_IS_WORKER) {
            readBinary = (url) => {
                var xhr = new XMLHttpRequest();
                xhr.open("GET", url, false);
                xhr.responseType = "arraybuffer";
                xhr.send(null);
                return new Uint8Array(/** @type{!ArrayBuffer} */ (xhr.response));
            };
        }

        readAsync = (url, onload, onerror) => {
            var xhr = new XMLHttpRequest();
            xhr.open("GET", url, true);
            xhr.responseType = "arraybuffer";
            xhr.onload = () => {
                if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) {
                    // file URLs can return 0
                    onload(xhr.response);
                    return;
                }
                onerror();
            };
            xhr.onerror = onerror;
            xhr.send(null);
        };

        // end include: web_or_worker_shell_read.js
    }

    setWindowTitle = (title) => (document.title = title);
} else {
    throw new Error("environment detection error");
}

var out = Module["print"] || console.log.bind(console);
var err = Module["printErr"] || console.warn.bind(console);

// Merge back in the overrides
Object.assign(Module, moduleOverrides);
// Free the object hierarchy contained in the overrides, this lets the GC
// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array.
moduleOverrides = null;

// Emit code to handle expected values on the Module object. This applies Module.x
// to the proper local x. This has two benefits: first, we only emit it if it is
// expected to arrive, and second, by using a local everywhere else that can be
// minified.

if (Module["arguments"]) arguments_ = Module["arguments"];
if (!Object.getOwnPropertyDescriptor(Module, "arguments")) {
    Object.defineProperty(Module, "arguments", {
        configurable: true,
        get: function () {
            abort(
                "Module.arguments has been replaced with plain arguments_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"
            );
        },
    });
}

if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
if (!Object.getOwnPropertyDescriptor(Module, "thisProgram")) {
    Object.defineProperty(Module, "thisProgram", {
        configurable: true,
        get: function () {
            abort(
                "Module.thisProgram has been replaced with plain thisProgram (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"
            );
        },
    });
}

if (Module["quit"]) quit_ = Module["quit"];
if (!Object.getOwnPropertyDescriptor(Module, "quit")) {
    Object.defineProperty(Module, "quit", {
        configurable: true,
        get: function () {
            abort(
                "Module.quit has been replaced with plain quit_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"
            );
        },
    });
}

// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message
// Assertions on removed incoming Module JS APIs.
assert(
    typeof Module["memoryInitializerPrefixURL"] == "undefined",
    "Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead"
);
assert(
    typeof Module["pthreadMainPrefixURL"] == "undefined",
    "Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead"
);
assert(
    typeof Module["cdInitializerPrefixURL"] == "undefined",
    "Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead"
);
assert(
    typeof Module["filePackagePrefixURL"] == "undefined",
    "Module.filePackagePrefixURL option was removed, use Module.locateFile instead"
);
assert(typeof Module["read"] == "undefined", "Module.read option was removed (modify read_ in JS)");
assert(
    typeof Module["readAsync"] == "undefined",
    "Module.readAsync option was removed (modify readAsync in JS)"
);
assert(
    typeof Module["readBinary"] == "undefined",
    "Module.readBinary option was removed (modify readBinary in JS)"
);
assert(
    typeof Module["setWindowTitle"] == "undefined",
    "Module.setWindowTitle option was removed (modify setWindowTitle in JS)"
);
assert(
    typeof Module["TOTAL_MEMORY"] == "undefined",
    "Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY"
);

if (!Object.getOwnPropertyDescriptor(Module, "read")) {
    Object.defineProperty(Module, "read", {
        configurable: true,
        get: function () {
            abort(
                "Module.read has been replaced with plain read_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"
            );
        },
    });
}

if (!Object.getOwnPropertyDescriptor(Module, "readAsync")) {
    Object.defineProperty(Module, "readAsync", {
        configurable: true,
        get: function () {
            abort(
                "Module.readAsync has been replaced with plain readAsync (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"
            );
        },
    });
}

if (!Object.getOwnPropertyDescriptor(Module, "readBinary")) {
    Object.defineProperty(Module, "readBinary", {
        configurable: true,
        get: function () {
            abort(
                "Module.readBinary has been replaced with plain readBinary (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"
            );
        },
    });
}

if (!Object.getOwnPropertyDescriptor(Module, "setWindowTitle")) {
    Object.defineProperty(Module, "setWindowTitle", {
        configurable: true,
        get: function () {
            abort(
                "Module.setWindowTitle has been replaced with plain setWindowTitle (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"
            );
        },
    });
}
var IDBFS = "IDBFS is no longer included by default; build with -lidbfs.js";
var PROXYFS = "PROXYFS is no longer included by default; build with -lproxyfs.js";
var WORKERFS = "WORKERFS is no longer included by default; build with -lworkerfs.js";
var NODEFS = "NODEFS is no longer included by default; build with -lnodefs.js";
function alignMemory() {
    abort(
        "`alignMemory` is now a library function and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line"
    );
}

assert(
    !ENVIRONMENT_IS_WORKER,
    "worker environment detected but not enabled at build time.  Add 'worker' to `-s ENVIRONMENT` to enable."
);

assert(
    !ENVIRONMENT_IS_NODE,
    "node environment detected but not enabled at build time.  Add 'node' to `-s ENVIRONMENT` to enable."
);

assert(
    !ENVIRONMENT_IS_SHELL,
    "shell environment detected but not enabled at build time.  Add 'shell' to `-s ENVIRONMENT` to enable."
);

var STACK_ALIGN = 16;
var POINTER_SIZE = 4;

function getNativeTypeSize(type) {
    switch (type) {
        case "i1":
        case "i8":
            return 1;
        case "i16":
            return 2;
        case "i32":
            return 4;
        case "i64":
            return 8;
        case "float":
            return 4;
        case "double":
            return 8;
        default: {
            if (type[type.length - 1] === "*") {
                return POINTER_SIZE;
            } else if (type[0] === "i") {
                const bits = Number(type.substr(1));
                assert(bits % 8 === 0, "getNativeTypeSize invalid bits " + bits + ", type " + type);
                return bits / 8;
            } else {
                return 0;
            }
        }
    }
}

function warnOnce(text) {
    if (!warnOnce.shown) warnOnce.shown = {};
    if (!warnOnce.shown[text]) {
        warnOnce.shown[text] = 1;
        err(text);
    }
}

// include: runtime_functions.js

// Wraps a JS function as a wasm function with a given signature.
function convertJsFunctionToWasm(func, sig) {
    // If the type reflection proposal is available, use the new
    // "WebAssembly.Function" constructor.
    // Otherwise, construct a minimal wasm module importing the JS function and
    // re-exporting it.
    if (typeof WebAssembly.Function == "function") {
        var typeNames = {
            i: "i32",
            j: "i64",
            f: "f32",
            d: "f64",
        };
        var type = {
            parameters: [],
            results: sig[0] == "v" ? [] : [typeNames[sig[0]]],
        };
        for (var i = 1; i < sig.length; ++i) {
            type.parameters.push(typeNames[sig[i]]);
        }
        return new WebAssembly.Function(type, func);
    }

    // The module is static, with the exception of the type section, which is
    // generated based on the signature passed in.
    var typeSection = [
        0x01, // id: section,
        0x00, // length: 0 (placeholder)
        0x01, // count: 1
        0x60, // form: func
    ];
    var sigRet = sig.slice(0, 1);
    var sigParam = sig.slice(1);
    var typeCodes = {
        i: 0x7f, // i32
        j: 0x7e, // i64
        f: 0x7d, // f32
        d: 0x7c, // f64
    };

    // Parameters, length + signatures
    typeSection.push(sigParam.length);
    for (var i = 0; i < sigParam.length; ++i) {
        typeSection.push(typeCodes[sigParam[i]]);
    }

    // Return values, length + signatures
    // With no multi-return in MVP, either 0 (void) or 1 (anything else)
    if (sigRet == "v") {
        typeSection.push(0x00);
    } else {
        typeSection = typeSection.concat([0x01, typeCodes[sigRet]]);
    }

    // Write the overall length of the type section back into the section header
    // (excepting the 2 bytes for the section id and length)
    typeSection[1] = typeSection.length - 2;

    // Rest of the module is static
    var bytes = new Uint8Array(
        [
            0x00,
            0x61,
            0x73,
            0x6d, // magic ("\0asm")
            0x01,
            0x00,
            0x00,
            0x00, // version: 1
        ].concat(typeSection, [
            0x02,
            0x07, // import section
            // (import "e" "f" (func 0 (type 0)))
            0x01,
            0x01,
            0x65,
            0x01,
            0x66,
            0x00,
            0x00,
            0x07,
            0x05, // export section
            // (export "f" (func 0 (type 0)))
            0x01,
            0x01,
            0x66,
            0x00,
            0x00,
        ])
    );

    // We can compile this wasm module synchronously because it is very small.
    // This accepts an import (at "e.f"), that it reroutes to an export (at "f")
    // eslint-disable-next-line @next/next/no-assign-module-variable
    var module = new WebAssembly.Module(bytes);
    var instance = new WebAssembly.Instance(module, {
        e: {
            f: func,
        },
    });
    var wrappedFunc = instance.exports["f"];
    return wrappedFunc;
}

var freeTableIndexes = [];

// Weak map of functions in the table to their indexes, created on first use.
var functionsInTableMap;

function getEmptyTableSlot() {
    // Reuse a free index if there is one, otherwise grow.
    if (freeTableIndexes.length) {
        return freeTableIndexes.pop();
    }
    // Grow the table
    try {
        wasmTable.grow(1);
    } catch (err) {
        if (!(err instanceof RangeError)) {
            throw err;
        }
        throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.";
    }
    return wasmTable.length - 1;
}

function updateTableMap(offset, count) {
    for (var i = offset; i < offset + count; i++) {
        var item = getWasmTableEntry(i);
        // Ignore null values.
        if (item) {
            functionsInTableMap.set(item, i);
        }
    }
}

/**
 * Add a function to the table.
 * 'sig' parameter is required if the function being added is a JS function.
 * @param {string=} sig
 */
function addFunction(func, sig) {
    assert(typeof func != "undefined");

    // Check if the function is already in the table, to ensure each function
    // gets a unique index. First, create the map if this is the first use.
    if (!functionsInTableMap) {
        functionsInTableMap = new WeakMap();
        updateTableMap(0, wasmTable.length);
    }
    if (functionsInTableMap.has(func)) {
        return functionsInTableMap.get(func);
    }

    // It's not in the table, add it now.

    var ret = getEmptyTableSlot();

    // Set the new value.
    try {
        // Attempting to call this with JS function will cause of table.set() to fail
        setWasmTableEntry(ret, func);
    } catch (err) {
        if (!(err instanceof TypeError)) {
            throw err;
        }
        assert(typeof sig != "undefined", "Missing signature argument to addFunction: " + func);
        var wrapped = convertJsFunctionToWasm(func, sig);
        setWasmTableEntry(ret, wrapped);
    }

    functionsInTableMap.set(func, ret);

    return ret;
}

function removeFunction(index) {
    functionsInTableMap.delete(getWasmTableEntry(index));
    freeTableIndexes.push(index);
}

// end include: runtime_functions.js
// include: runtime_debug.js

// end include: runtime_debug.js
var tempRet0 = 0;
var setTempRet0 = (value) => {
    tempRet0 = value;
};
var getTempRet0 = () => tempRet0;

// === Preamble library stuff ===

// Documentation for the public APIs defined in this file must be updated in:
//    site/source/docs/api_reference/preamble.js.rst
// A prebuilt local version of the documentation is available at:
//    site/build/text/docs/api_reference/preamble.js.txt
// You can also build docs locally as HTML or other formats in site/
// An online HTML version (which may be of a different version of Emscripten)
//    is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html

var wasmBinary;
if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
if (!Object.getOwnPropertyDescriptor(Module, "wasmBinary")) {
    Object.defineProperty(Module, "wasmBinary", {
        configurable: true,
        get: function () {
            abort(
                "Module.wasmBinary has been replaced with plain wasmBinary (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"
            );
        },
    });
}
var noExitRuntime = Module["noExitRuntime"] || true;
if (!Object.getOwnPropertyDescriptor(Module, "noExitRuntime")) {
    Object.defineProperty(Module, "noExitRuntime", {
        configurable: true,
        get: function () {
            abort(
                "Module.noExitRuntime has been replaced with plain noExitRuntime (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"
            );
        },
    });
}

if (typeof WebAssembly != "object") {
    abort("no native wasm support detected");
}

// include: runtime_safe_heap.js

// In MINIMAL_RUNTIME, setValue() and getValue() are only available when building with safe heap enabled, for heap safety checking.
// In traditional runtime, setValue() and getValue() are always available (although their use is highly discouraged due to perf penalties)

/** @param {number} ptr
    @param {number} value
    @param {string} type
    @param {number|boolean=} noSafe */
function setValue(ptr, value, type = "i8", noSafe) {
    if (type.charAt(type.length - 1) === "*") type = "i32";
    switch (type) {
        case "i1":
            HEAP8[ptr >> 0] = value;
            break;
        case "i8":
            HEAP8[ptr >> 0] = value;
            break;
        case "i16":
            HEAP16[ptr >> 1] = value;
            break;
        case "i32":
            HEAP32[ptr >> 2] = value;
            break;
        case "i64":
            (tempI64 = [
                value >>> 0,
                ((tempDouble = value),
                +Math.abs(tempDouble) >= 1.0
                    ? tempDouble > 0.0
                        ? (Math.min(+Math.floor(tempDouble / 4294967296.0), 4294967295.0) | 0) >>> 0
                        : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296.0) >>> 0
                    : 0),
            ]),
                (HEAP32[ptr >> 2] = tempI64[0]),
                (HEAP32[(ptr + 4) >> 2] = tempI64[1]);
            break;
        case "float":
            HEAPF32[ptr >> 2] = value;
            break;
        case "double":
            HEAPF64[ptr >> 3] = value;
            break;
        default:
            abort("invalid type for setValue: " + type);
    }
}

/** @param {number} ptr
    @param {string} type
    @param {number|boolean=} noSafe */
function getValue(ptr, type = "i8", noSafe) {
    if (type.charAt(type.length - 1) === "*") type = "i32";
    switch (type) {
        case "i1":
            return HEAP8[ptr >> 0];
        case "i8":
            return HEAP8[ptr >> 0];
        case "i16":
            return HEAP16[ptr >> 1];
        case "i32":
            return HEAP32[ptr >> 2];
        case "i64":
            return HEAP32[ptr >> 2];
        case "float":
            return HEAPF32[ptr >> 2];
        case "double":
            return Number(HEAPF64[ptr >> 3]);
        default:
            abort("invalid type for getValue: " + type);
    }
    return null;
}

// end include: runtime_safe_heap.js
// Wasm globals

var wasmMemory;

//========================================
// Runtime essentials
//========================================

// whether we are quitting the application. no code should run after this.
// set in exit() and abort()
var ABORT = false;

// set by exit() and abort().  Passed to 'onExit' handler.
// NOTE: This is also used as the process return code code in shell environments
// but only when noExitRuntime is false.
var EXITSTATUS;

/** @type {function(*, string=)} */
function assert(condition, text) {
    if (!condition) {
        abort("Assertion failed" + (text ? ": " + text : ""));
    }
}

// Returns the C function with a specified identifier (for C++, you need to do manual name mangling)
function getCFunc(ident) {
    var func = Module["_" + ident]; // closure exported function
    assert(func, "Cannot call unknown function " + ident + ", make sure it is exported");
    return func;
}

// C calling interface.
/** @param {string|null=} returnType
    @param {Array=} argTypes
    @param {Arguments|Array=} args
    @param {Object=} opts */
function ccall(ident, returnType, argTypes, args, opts) {
    // For fast lookup of conversion functions
    var toC = {
        string: function (str) {
            var ret = 0;
            if (str !== null && str !== undefined && str !== 0) {
                // null string
                // at most 4 bytes per UTF-8 code point, +1 for the trailing '\0'
                var len = (str.length << 2) + 1;
                ret = stackAlloc(len);
                stringToUTF8(str, ret, len);
            }
            return ret;
        },
        array: function (arr) {
            var ret = stackAlloc(arr.length);
            writeArrayToMemory(arr, ret);
            return ret;
        },
    };

    function convertReturnValue(ret) {
        if (returnType === "string") return UTF8ToString(ret);
        if (returnType === "boolean") return Boolean(ret);
        return ret;
    }

    var func = getCFunc(ident);
    var cArgs = [];
    var stack = 0;
    assert(returnType !== "array", 'Return type should not be "array".');
    if (args) {
        for (var i = 0; i < args.length; i++) {
            var converter = toC[argTypes[i]];
            if (converter) {
                if (stack === 0) stack = stackSave();
                cArgs[i] = converter(args[i]);
            } else {
                cArgs[i] = args[i];
            }
        }
    }
    var ret = func.apply(null, cArgs);
    function onDone(ret) {
        if (stack !== 0) stackRestore(stack);
        return convertReturnValue(ret);
    }

    ret = onDone(ret);
    return ret;
}

/** @param {string=} returnType
    @param {Array=} argTypes
    @param {Object=} opts */
function cwrap(ident, returnType, argTypes, opts) {
    return function () {
        return ccall(ident, returnType, argTypes, arguments, opts);
    };
}

// We used to include malloc/free by default in the past. Show a helpful error in
// builds with assertions.
function _malloc() {
    abort("malloc() called but not included in the build - add '_malloc' to EXPORTED_FUNCTIONS");
}
function _free() {
    // Show a helpful error since we used to include free by default in the past.
    abort("free() called but not included in the build - add '_free' to EXPORTED_FUNCTIONS");
}

// include: runtime_legacy.js

var ALLOC_NORMAL = 0; // Tries to use _malloc()
var ALLOC_STACK = 1; // Lives for the duration of the current function call

/**
 * allocate(): This function is no longer used by emscripten but is kept around to avoid
 *             breaking external users.
 *             You should normally not use allocate(), and instead allocate
 *             memory using _malloc()/stackAlloc(), initialize it with
 *             setValue(), and so forth.
 * @param {(Uint8Array|Array<number>)} slab: An array of data.
 * @param {number=} allocator : How to allocate memory, see ALLOC_*
 */
function allocate(slab, allocator) {
    var ret;
    assert(typeof allocator == "number", "allocate no longer takes a type argument");
    assert(typeof slab != "number", "allocate no longer takes a number as arg0");

    if (allocator == ALLOC_STACK) {
        ret = stackAlloc(slab.length);
    } else {
        ret = abort(
            'malloc was not included, but is needed in allocate. Adding "_malloc" to EXPORTED_FUNCTIONS should fix that. This may be a bug in the compiler, please file an issue.'
        );
    }

    if (!slab.subarray && !slab.slice) {
        slab = new Uint8Array(slab);
    }
    HEAPU8.set(slab, ret);
    return ret;
}

// end include: runtime_legacy.js
// include: runtime_strings.js

// runtime_strings.js: Strings related runtime functions that are part of both MINIMAL_RUNTIME and regular runtime.

// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the given array that contains uint8 values, returns
// a copy of that string as a Javascript String object.

var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined;

/**
 * @param {number} idx
 * @param {number=} maxBytesToRead
 * @return {string}
 */
function UTF8ArrayToString(heap, idx, maxBytesToRead) {
    var endIdx = idx + maxBytesToRead;
    var endPtr = idx;
    // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself.
    // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage.
    // (As a tiny code save trick, compare endPtr against endIdx using a negation, so that undefined means Infinity)
    while (heap[endPtr] && !(endPtr >= endIdx)) ++endPtr;

    if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) {
        return UTF8Decoder.decode(heap.subarray(idx, endPtr));
    } else {
        var str = "";
        // If building with TextDecoder, we have already computed the string length above, so test loop end condition against that
        while (idx < endPtr) {
            // For UTF8 byte structure, see:
            // http://en.wikipedia.org/wiki/UTF-8#Description
            // https://www.ietf.org/rfc/rfc2279.txt
            // https://tools.ietf.org/html/rfc3629
            var u0 = heap[idx++];
            if (!(u0 & 0x80)) {
                str += String.fromCharCode(u0);
                continue;
            }
            var u1 = heap[idx++] & 63;
            if ((u0 & 0xe0) == 0xc0) {
                str += String.fromCharCode(((u0 & 31) << 6) | u1);
                continue;
            }
            var u2 = heap[idx++] & 63;
            if ((u0 & 0xf0) == 0xe0) {
                u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
            } else {
                if ((u0 & 0xf8) != 0xf0)
                    warnOnce(
                        "Invalid UTF-8 leading byte 0x" +
                            u0.toString(16) +
                            " encountered when deserializing a UTF-8 string in wasm memory to a JS string!"
                    );
                u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heap[idx++] & 63);
            }

            if (u0 < 0x10000) {
                str += String.fromCharCode(u0);
            } else {
                var ch = u0 - 0x10000;
                str += String.fromCharCode(0xd800 | (ch >> 10), 0xdc00 | (ch & 0x3ff));
            }
        }
    }
    return str;
}

// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the emscripten HEAP, returns a
// copy of that string as a Javascript String object.
// maxBytesToRead: an optional length that specifies the maximum number of bytes to read. You can omit
//                 this parameter to scan the string until the first \0 byte. If maxBytesToRead is
//                 passed, and the string at [ptr, ptr+maxBytesToReadr[ contains a null byte in the
//                 middle, then the string will cut short at that byte index (i.e. maxBytesToRead will
//                 not produce a string of exact length [ptr, ptr+maxBytesToRead[)
//                 N.B. mixing frequent uses of UTF8ToString() with and without maxBytesToRead may
//                 throw JS JIT optimizations off, so it is worth to consider consistently using one
//                 style or the other.
/**
 * @param {number} ptr
 * @param {number=} maxBytesToRead
 * @return {string}
 */
function UTF8ToString(ptr, maxBytesToRead) {
    return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
}

// Copies the given Javascript String object 'str' to the given byte array at address 'outIdx',
// encoded in UTF8 form and null-terminated. The copy will require at most str.length*4+1 bytes of space in the HEAP.
// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write.
// Parameters:
//   str: the Javascript string to copy.
//   heap: the array to copy to. Each index in this array is assumed to be one 8-byte element.
//   outIdx: The starting offset in the array to begin the copying.
//   maxBytesToWrite: The maximum number of bytes this function can write to the array.
//                    This count should include the null terminator,
//                    i.e. if maxBytesToWrite=1, only the null terminator will be written and nothing else.
//                    maxBytesToWrite=0 does not write any bytes to the output, not even the null terminator.
// Returns the number of bytes written, EXCLUDING the null terminator.

function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
    if (!(maxBytesToWrite > 0))
        // Parameter maxBytesToWrite is not optional. Negative values, 0, null, undefined and false each don't write out any bytes.
        return 0;

    var startIdx = outIdx;
    var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator.
    for (var i = 0; i < str.length; ++i) {
        // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8.
        // See http://unicode.org/faq/utf_bom.html#utf16-3
        // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description and https://www.ietf.org/rfc/rfc2279.txt and https://tools.ietf.org/html/rfc3629
        var u = str.charCodeAt(i); // possibly a lead surrogate
        if (u >= 0xd800 && u <= 0xdfff) {
            var u1 = str.charCodeAt(++i);
            u = (0x10000 + ((u & 0x3ff) << 10)) | (u1 & 0x3ff);
        }
        if (u <= 0x7f) {
            if (outIdx >= endIdx) break;
            heap[outIdx++] = u;
        } else if (u <= 0x7ff) {
            if (outIdx + 1 >= endIdx) break;
            heap[outIdx++] = 0xc0 | (u >> 6);
            heap[outIdx++] = 0x80 | (u & 63);
        } else if (u <= 0xffff) {
            if (outIdx + 2 >= endIdx) break;
            heap[outIdx++] = 0xe0 | (u >> 12);
            heap[outIdx++] = 0x80 | ((u >> 6) & 63);
            heap[outIdx++] = 0x80 | (u & 63);
        } else {
            if (outIdx + 3 >= endIdx) break;
            if (u > 0x10ffff)
                warnOnce(
                    "Invalid Unicode code point 0x" +
                        u.toString(16) +
                        " encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF)."
                );
            heap[outIdx++] = 0xf0 | (u >> 18);
            heap[outIdx++] = 0x80 | ((u >> 12) & 63);
            heap[outIdx++] = 0x80 | ((u >> 6) & 63);
            heap[outIdx++] = 0x80 | (u & 63);
        }
    }
    // Null-terminate the pointer to the buffer.
    heap[outIdx] = 0;
    return outIdx - startIdx;
}

// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
// null-terminated and encoded in UTF8 form. The copy will require at most str.length*4+1 bytes of space in the HEAP.
// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write.
// Returns the number of bytes written, EXCLUDING the null terminator.

function stringToUTF8(str, outPtr, maxBytesToWrite) {
    assert(
        typeof maxBytesToWrite == "number",
        "stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!"
    );
    return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
}

// Returns the number of bytes the given Javascript string takes if encoded as a UTF8 byte array, EXCLUDING the null terminator byte.
function lengthBytesUTF8(str) {
    var len = 0;
    for (var i = 0; i < str.length; ++i) {
        // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8.
        // See http://unicode.org/faq/utf_bom.html#utf16-3
        var u = str.charCodeAt(i); // possibly a lead surrogate
        if (u >= 0xd800 && u <= 0xdfff)
            u = (0x10000 + ((u & 0x3ff) << 10)) | (str.charCodeAt(++i) & 0x3ff);
        if (u <= 0x7f) ++len;
        else if (u <= 0x7ff) len += 2;
        else if (u <= 0xffff) len += 3;
        else len += 4;
    }
    return len;
}

// end include: runtime_strings.js
// include: runtime_strings_extra.js

// runtime_strings_extra.js: Strings related runtime functions that are available only in regular runtime.

// Given a pointer 'ptr' to a null-terminated ASCII-encoded string in the emscripten HEAP, returns
// a copy of that string as a Javascript String object.

function AsciiToString(ptr) {
    var str = "";
    while (1) {
        var ch = HEAPU8[ptr++ >> 0];
        if (!ch) return str;
        str += String.fromCharCode(ch);
    }
}

// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
// null-terminated and encoded in ASCII form. The copy will require at most str.length+1 bytes of space in the HEAP.

function stringToAscii(str, outPtr) {
    return writeAsciiToMemory(str, outPtr, false);
}

// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns
// a copy of that string as a Javascript String object.

var UTF16Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf-16le") : undefined;

function UTF16ToString(ptr, maxBytesToRead) {
    assert(ptr % 2 == 0, "Pointer passed to UTF16ToString must be aligned to two bytes!");
    var endPtr = ptr;
    // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself.
    // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage.
    var idx = endPtr >> 1;
    var maxIdx = idx + maxBytesToRead / 2;
    // If maxBytesToRead is not passed explicitly, it will be undefined, and this
    // will always evaluate to true. This saves on code size.
    while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx;
    endPtr = idx << 1;

    if (endPtr - ptr > 32 && UTF16Decoder) {
        return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));
    } else {
        var str = "";

        // If maxBytesToRead is not passed explicitly, it will be undefined, and the for-loop's condition
        // will always evaluate to true. The loop is then terminated on the first null char.
        for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
            var codeUnit = HEAP16[(ptr + i * 2) >> 1];
            if (codeUnit == 0) break;
            // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through.
            str += String.fromCharCode(codeUnit);
        }

        return str;
    }
}

// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
// null-terminated and encoded in UTF16 form. The copy will require at most str.length*4+2 bytes of space in the HEAP.
// Use the function lengthBytesUTF16() to compute the exact number of bytes (excluding null terminator) that this function will write.
// Parameters:
//   str: the Javascript string to copy.
//   outPtr: Byte address in Emscripten HEAP where to write the string to.
//   maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null
//                    terminator, i.e. if maxBytesToWrite=2, only the null terminator will be written and nothing else.
//                    maxBytesToWrite<2 does not write any bytes to the output, not even the null terminator.
// Returns the number of bytes written, EXCLUDING the null terminator.

function stringToUTF16(str, outPtr, maxBytesToWrite) {
    assert(outPtr % 2 == 0, "Pointer passed to stringToUTF16 must be aligned to two bytes!");
    assert(
        typeof maxBytesToWrite == "number",
        "stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!"
    );
    // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.
    if (maxBytesToWrite === undefined) {
        maxBytesToWrite = 0x7fffffff;
    }
    if (maxBytesToWrite < 2) return 0;
    maxBytesToWrite -= 2; // Null terminator.
    var startPtr = outPtr;
    var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
    for (var i = 0; i < numCharsToWrite; ++i) {
        // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.
        var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
        HEAP16[outPtr >> 1] = codeUnit;
        outPtr += 2;
    }
    // Null-terminate the pointer to the HEAP.
    HEAP16[outPtr >> 1] = 0;
    return outPtr - startPtr;
}

// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte.

function lengthBytesUTF16(str) {
    return str.length * 2;
}

function UTF32ToString(ptr, maxBytesToRead) {
    assert(ptr % 4 == 0, "Pointer passed to UTF32ToString must be aligned to four bytes!");
    var i = 0;

    var str = "";
    // If maxBytesToRead is not passed explicitly, it will be undefined, and this
    // will always evaluate to true. This saves on code size.
    while (!(i >= maxBytesToRead / 4)) {
        var utf32 = HEAP32[(ptr + i * 4) >> 2];
        if (utf32 == 0) break;
        ++i;
        // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing.
        // See http://unicode.org/faq/utf_bom.html#utf16-3
        if (utf32 >= 0x10000) {
            var ch = utf32 - 0x10000;
            str += String.fromCharCode(0xd800 | (ch >> 10), 0xdc00 | (ch & 0x3ff));
        } else {
            str += String.fromCharCode(utf32);
        }
    }
    return str;
}

// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
// null-terminated and encoded in UTF32 form. The copy will require at most str.length*4+4 bytes of space in the HEAP.
// Use the function lengthBytesUTF32() to compute the exact number of bytes (excluding null terminator) that this function will write.
// Parameters:
//   str: the Javascript string to copy.
//   outPtr: Byte address in Emscripten HEAP where to write the string to.
//   maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null
//                    terminator, i.e. if maxBytesToWrite=4, only the null terminator will be written and nothing else.
//                    maxBytesToWrite<4 does not write any bytes to the output, not even the null terminator.
// Returns the number of bytes written, EXCLUDING the null terminator.

function stringToUTF32(str, outPtr, maxBytesToWrite) {
    assert(outPtr % 4 == 0, "Pointer passed to stringToUTF32 must be aligned to four bytes!");
    assert(
        typeof maxBytesToWrite == "number",
        "stringToUTF32(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!"
    );
    // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.
    if (maxBytesToWrite === undefined) {
        maxBytesToWrite = 0x7fffffff;
    }
    if (maxBytesToWrite < 4) return 0;
    var startPtr = outPtr;
    var endPtr = startPtr + maxBytesToWrite - 4;
    for (var i = 0; i < str.length; ++i) {
        // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
        // See http://unicode.org/faq/utf_bom.html#utf16-3
        var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
        if (codeUnit >= 0xd800 && codeUnit <= 0xdfff) {
            var trailSurrogate = str.charCodeAt(++i);
            codeUnit = (0x10000 + ((codeUnit & 0x3ff) << 10)) | (trailSurrogate & 0x3ff);
        }
        HEAP32[outPtr >> 2] = codeUnit;
        outPtr += 4;
        if (outPtr + 4 > endPtr) break;
    }
    // Null-terminate the pointer to the HEAP.
    HEAP32[outPtr >> 2] = 0;
    return outPtr - startPtr;
}

// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte.

function lengthBytesUTF32(str) {
    var len = 0;
    for (var i = 0; i < str.length; ++i) {
        // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
        // See http://unicode.org/faq/utf_bom.html#utf16-3
        var codeUnit = str.charCodeAt(i);
        if (codeUnit >= 0xd800 && codeUnit <= 0xdfff) ++i; // possibly a lead surrogate, so skip over the tail surrogate.
        len += 4;
    }

    return len;
}

// Allocate heap space for a JS string, and write it there.
// It is the responsibility of the caller to free() that memory.
function allocateUTF8(str) {
    var size = lengthBytesUTF8(str) + 1;
    var ret = abort(
        'malloc was not included, but is needed in allocateUTF8. Adding "_malloc" to EXPORTED_FUNCTIONS should fix that. This may be a bug in the compiler, please file an issue.'
    );
    if (ret) stringToUTF8Array(str, HEAP8, ret, size);
    return ret;
}

// Allocate stack space for a JS string, and write it there.
function allocateUTF8OnStack(str) {
    var size = lengthBytesUTF8(str) + 1;
    var ret = stackAlloc(size);
    stringToUTF8Array(str, HEAP8, ret, size);
    return ret;
}

// Deprecated: This function should not be called because it is unsafe and does not provide
// a maximum length limit of how many bytes it is allowed to write. Prefer calling the
// function stringToUTF8Array() instead, which takes in a maximum length that can be used
// to be secure from out of bounds writes.
/** @deprecated
    @param {boolean=} dontAddNull */
function writeStringToMemory(string, buffer, dontAddNull) {
    warnOnce(
        "writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!"
    );

    var /** @type {number} */ lastChar, /** @type {number} */ end;
    if (dontAddNull) {
        // stringToUTF8Array always appends null. If we don't want to do that, remember the
        // character that existed at the location where the null will be placed, and restore
        // that after the write (below).
        end = buffer + lengthBytesUTF8(string);
        lastChar = HEAP8[end];
    }
    stringToUTF8(string, buffer, Infinity);
    if (dontAddNull) HEAP8[end] = lastChar; // Restore the value under the null character.
}

function writeArrayToMemory(array, buffer) {
    assert(
        array.length >= 0,
        "writeArrayToMemory array must have a length (should be an array or typed array)"
    );
    HEAP8.set(array, buffer);
}

/** @param {boolean=} dontAddNull */
function writeAsciiToMemory(str, buffer, dontAddNull) {
    for (var i = 0; i < str.length; ++i) {
        assert(str.charCodeAt(i) === (str.charCodeAt(i) & 0xff));
        HEAP8[buffer++ >> 0] = str.charCodeAt(i);
    }
    // Null-terminate the pointer to the HEAP.
    if (!dontAddNull) HEAP8[buffer >> 0] = 0;
}

// end include: runtime_strings_extra.js
// Memory management

function alignUp(x, multiple) {
    if (x % multiple > 0) {
        x += multiple - (x % multiple);
    }
    return x;
}

var HEAP,
    /** @type {ArrayBuffer} */
    buffer,
    /** @type {Int8Array} */
    HEAP8,
    /** @type {Uint8Array} */
    HEAPU8,
    /** @type {Int16Array} */
    HEAP16,
    /** @type {Uint16Array} */
    HEAPU16,
    /** @type {Int32Array} */
    HEAP32,
    /** @type {Uint32Array} */
    HEAPU32,
    /** @type {Float32Array} */
    HEAPF32,
    /** @type {Float64Array} */
    HEAPF64;

function updateGlobalBufferAndViews(buf) {
    buffer = buf;
    Module["HEAP8"] = HEAP8 = new Int8Array(buf);
    Module["HEAP16"] = HEAP16 = new Int16Array(buf);
    Module["HEAP32"] = HEAP32 = new Int32Array(buf);
    Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf);
    Module["HEAPU16"] = HEAPU16 = new Uint16Array(buf);
    Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf);
    Module["HEAPF32"] = HEAPF32 = new Float32Array(buf);
    Module["HEAPF64"] = HEAPF64 = new Float64Array(buf);
}

var TOTAL_STACK = 5242880;
if (Module["TOTAL_STACK"])
    assert(
        TOTAL_STACK === Module["TOTAL_STACK"],
        "the stack size can no longer be determined at runtime"
    );

var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 16777216;
if (!Object.getOwnPropertyDescriptor(Module, "INITIAL_MEMORY")) {
    Object.defineProperty(Module, "INITIAL_MEMORY", {
        configurable: true,
        get: function () {
            abort(
                "Module.INITIAL_MEMORY has been replaced with plain INITIAL_MEMORY (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"
            );
        },
    });
}

assert(
    INITIAL_MEMORY >= TOTAL_STACK,
    "INITIAL_MEMORY should be larger than TOTAL_STACK, was " +
        INITIAL_MEMORY +
        "! (TOTAL_STACK=" +
        TOTAL_STACK +
        ")"
);

// check for full engine support (use string 'subarray' to avoid closure compiler confusion)
assert(
    typeof Int32Array != "undefined" &&
        typeof Float64Array !== "undefined" &&
        Int32Array.prototype.subarray != undefined &&
        Int32Array.prototype.set != undefined,
    "JS engine does not provide full typed array support"
);

// If memory is defined in wasm, the user can't provide it.
assert(
    !Module["wasmMemory"],
    "Use of `wasmMemory` detected.  Use -s IMPORTED_MEMORY to define wasmMemory externally"
);
assert(
    INITIAL_MEMORY == 16777216,
    "Detected runtime INITIAL_MEMORY setting.  Use -s IMPORTED_MEMORY to define wasmMemory dynamically"
);

// include: runtime_init_table.js
// In regular non-RELOCATABLE mode the table is exported
// from the wasm module and this will be assigned once
// the exports are available.
var wasmTable;

// end include: runtime_init_table.js
// include: runtime_stack_check.js

// Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode.
function writeStackCookie() {
    var max = _emscripten_stack_get_end();
    assert((max & 3) == 0);
    // The stack grows downwards
    HEAP32[(max + 4) >> 2] = 0x2135467;
    HEAP32[(max + 8) >> 2] = 0x89bacdfe;
    // Also test the global address 0 for integrity.
    HEAP32[0] = 0x63736d65; /* 'emsc' */
}

function checkStackCookie() {
    if (ABORT) return;
    var max = _emscripten_stack_get_end();
    var cookie1 = HEAPU32[(max + 4) >> 2];
    var cookie2 = HEAPU32[(max + 8) >> 2];
    if (cookie1 != 0x2135467 || cookie2 != 0x89bacdfe) {
        abort(
            "Stack overflow! Stack cookie has been overwritten, expected hex dwords 0x89BACDFE and 0x2135467, but received 0x" +
                cookie2.toString(16) +
                " 0x" +
                cookie1.toString(16)
        );
    }
    // Also test the global address 0 for integrity.
    if (HEAP32[0] !== 0x63736d65 /* 'emsc' */)
        abort("Runtime error: The application has corrupted its heap memory area (address zero)!");
}

// end include: runtime_stack_check.js
// include: runtime_assertions.js

// Endianness check
(function () {
    var h16 = new Int16Array(1);
    var h8 = new Int8Array(h16.buffer);
    h16[0] = 0x6373;
    if (h8[0] !== 0x73 || h8[1] !== 0x63)
        throw "Runtime error: expected the system to be little-endian! (Run with -s SUPPORT_BIG_ENDIAN=1 to bypass)";
})();

// end include: runtime_assertions.js
var __ATPRERUN__ = []; // functions called before the runtime is initialized
var __ATINIT__ = []; // functions called during startup
var __ATEXIT__ = []; // functions called during shutdown
var __ATPOSTRUN__ = []; // functions called after the main() is called

var runtimeInitialized = false;
var runtimeExited = false;
var runtimeKeepaliveCounter = 0;

function keepRuntimeAlive() {
    return noExitRuntime || runtimeKeepaliveCounter > 0;
}

function preRun() {
    if (Module["preRun"]) {
        if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]];
        while (Module["preRun"].length) {
            addOnPreRun(Module["preRun"].shift());
        }
    }

    callRuntimeCallbacks(__ATPRERUN__);
}

function initRuntime() {
    checkStackCookie();
    assert(!runtimeInitialized);
    runtimeInitialized = true;

    callRuntimeCallbacks(__ATINIT__);
}

function exitRuntime() {
    checkStackCookie();
    runtimeExited = true;
}

function postRun() {
    checkStackCookie();

    if (Module["postRun"]) {
        if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]];
        while (Module["postRun"].length) {
            addOnPostRun(Module["postRun"].shift());
        }
    }

    callRuntimeCallbacks(__ATPOSTRUN__);
}

function addOnPreRun(cb) {
    __ATPRERUN__.unshift(cb);
}

function addOnInit(cb) {
    __ATINIT__.unshift(cb);
}

function addOnExit(cb) {}

function addOnPostRun(cb) {
    __ATPOSTRUN__.unshift(cb);
}

// include: runtime_math.js

// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul

// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround

// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32

// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc

assert(
    Math.imul,
    "This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill"
);
assert(
    Math.fround,
    "This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill"
);
assert(
    Math.clz32,
    "This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill"
);
assert(
    Math.trunc,
    "This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill"
);

// end include: runtime_math.js
// A counter of dependencies for calling run(). If we need to
// do asynchronous work before running, increment this and
// decrement it. Incrementing must happen in a place like
// Module.preRun (used by emcc to add file preloading).
// Note that you can add dependencies in preRun, even though
// it happens right before run - run will be postponed until
// the dependencies are met.
var runDependencies = 0;
var runDependencyWatcher = null;
var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
var runDependencyTracking = {};

function getUniqueRunDependency(id) {
    var orig = id;
    while (1) {
        if (!runDependencyTracking[id]) return id;
        id = orig + Math.random();
    }
}

function addRunDependency(id) {
    runDependencies++;

    if (Module["monitorRunDependencies"]) {
        Module["monitorRunDependencies"](runDependencies);
    }

    if (id) {
        assert(!runDependencyTracking[id]);
        runDependencyTracking[id] = 1;
        if (runDependencyWatcher === null && typeof setInterval != "undefined") {
            // Check for missing dependencies every few seconds
            runDependencyWatcher = setInterval(function () {
                if (ABORT) {
                    clearInterval(runDependencyWatcher);
                    runDependencyWatcher = null;
                    return;
                }
                var shown = false;
                for (var dep in runDependencyTracking) {
                    if (!shown) {
                        shown = true;
                        err("still waiting on run dependencies:");
                    }
                    err("dependency: " + dep);
                }
                if (shown) {
                    err("(end of list)");
                }
            }, 10000);
        }
    } else {
        err("warning: run dependency added without ID");
    }
}

function removeRunDependency(id) {
    runDependencies--;

    if (Module["monitorRunDependencies"]) {
        Module["monitorRunDependencies"](runDependencies);
    }

    if (id) {
        assert(runDependencyTracking[id]);
        delete runDependencyTracking[id];
    } else {
        err("warning: run dependency removed without ID");
    }
    if (runDependencies == 0) {
        if (runDependencyWatcher !== null) {
            clearInterval(runDependencyWatcher);
            runDependencyWatcher = null;
        }
        if (dependenciesFulfilled) {
            var callback = dependenciesFulfilled;
            dependenciesFulfilled = null;
            callback(); // can add another dependenciesFulfilled
        }
    }
}

Module["preloadedImages"] = {}; // maps url to image data
Module["preloadedAudios"] = {}; // maps url to audio data

/** @param {string|number=} what */
function abort(what) {
    {
        if (Module["onAbort"]) {
            Module["onAbort"](what);
        }
    }

    what = "Aborted(" + what + ")";
    // TODO(sbc): Should we remove printing and leave it up to whoever
    // catches the exception?
    err(what);

    ABORT = true;
    EXITSTATUS = 1;

    // Use a wasm runtime error, because a JS error might be seen as a foreign
    // exception, which means we'd run destructors on it. We need the error to
    // simply make the program stop.

    // Suppress closure compiler warning here. Closure compiler's builtin extern
    // defintion for WebAssembly.RuntimeError claims it takes no arguments even
    // though it can.
    // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed.

    /** @suppress {checkTypes} */
    var e = new WebAssembly.RuntimeError(what);

    // Throw the error whether or not MODULARIZE is set because abort is used
    // in code paths apart from instantiation where an exception is expected
    // to be thrown when abort is called.
    throw e;
}

// {{MEM_INITIALIZER}}

// include: memoryprofiler.js

// end include: memoryprofiler.js
// show errors on likely calls to FS when it was not included
var FS = {
    error: function () {
        abort(
            "Filesystem support (FS) was not included. The problem is that you are using files from JS, but files were not used from C/C++, so filesystem support was not auto-included. You can force-include filesystem support with  -s FORCE_FILESYSTEM=1"
        );
    },
    init: function () {
        FS.error();
    },
    createDataFile: function () {
        FS.error();
    },
    createPreloadedFile: function () {
        FS.error();
    },
    createLazyFile: function () {
        FS.error();
    },
    open: function () {
        FS.error();
    },
    mkdev: function () {
        FS.error();
    },
    registerDevice: function () {
        FS.error();
    },
    analyzePath: function () {
        FS.error();
    },
    loadFilesFromDB: function () {
        FS.error();
    },

    ErrnoError: function ErrnoError() {
        FS.error();
    },
};
Module["FS_createDataFile"] = FS.createDataFile;
Module["FS_createPreloadedFile"] = FS.createPreloadedFile;

// include: URIUtils.js

// Prefix of data URIs emitted by SINGLE_FILE and related options.
var dataURIPrefix = "data:application/octet-stream;base64,";

// Indicates whether filename is a base64 data URI.
function isDataURI(filename) {
    // Prefix of data URIs emitted by SINGLE_FILE and related options.
    return filename.startsWith(dataURIPrefix);
}

// Indicates whether filename is delivered via file protocol (as opposed to http/https)
function isFileURI(filename) {
    return filename.startsWith("file://");
}

// end include: URIUtils.js
/** @param {boolean=} fixedasm */
function createExportWrapper(name, fixedasm) {
    return function () {
        var displayName = name;
        var asm = fixedasm;
        if (!fixedasm) {
            asm = Module["asm"];
        }
        assert(
            runtimeInitialized,
            "native function `" + displayName + "` called before runtime initialization"
        );
        assert(
            !runtimeExited,
            "native function `" +
                displayName +
                "` called after runtime exit (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
        );
        if (!asm[name]) {
            assert(asm[name], "exported native function `" + displayName + "` not found");
        }
        return asm[name].apply(null, arguments);
    };
}

var wasmBinaryFile;
wasmBinaryFile = "reCAPTCHA.wasm";
if (!isDataURI(wasmBinaryFile)) {
    wasmBinaryFile = locateFile(wasmBinaryFile);
}

function getBinary(file) {
    try {
        if (file == wasmBinaryFile && wasmBinary) {
            return new Uint8Array(wasmBinary);
        }
        if (readBinary) {
            return readBinary(file);
        } else {
            throw "both async and sync fetching of the wasm failed";
        }
    } catch (err) {
        abort(err);
    }
}

function getBinaryPromise() {
    // If we don't have the binary yet, try to to load it asynchronously.
    // Fetch has some additional restrictions over XHR, like it can't be used on a file:// url.
    // See https://github.com/github/fetch/pull/92#issuecomment-140665932
    // Cordova or Electron apps are typically loaded from a file:// url.
    // So use fetch if it is available and the url is not a file, otherwise fall back to XHR.
    if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
        if (typeof fetch == "function") {
            return fetch("https://koukoutu.sbqq.me/https://www.koukoutu.com/wasm/reCAPTCHA.js")
                .then(function (response) {
                    if (!response["ok"]) {
                        throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
                    }
                    return response["arrayBuffer"]();
                })
                .catch(function () {
                    return getBinary(wasmBinaryFile);
                });
        }
    }

    // Otherwise, getBinary should be able to get it synchronously
    return Promise.resolve().then(function () {
        return getBinary(wasmBinaryFile);
    });
}

// Create the wasm instance.
// Receives the wasm imports, returns the exports.
function createWasm() {
    // prepare imports
    var info = {
        env: asmLibraryArg,
        wasi_snapshot_preview1: asmLibraryArg,
    };
    // Load the wasm module and create an instance of using native support in the JS engine.
    // handle a generated wasm instance, receiving its exports and
    // performing other necessary setup
    /** @param {WebAssembly.Module=} module*/
    function receiveInstance(instance, module) {
        var exports = instance.exports;

        Module["asm"] = exports;

        wasmMemory = Module["asm"]["memory"];
        assert(wasmMemory, "memory not found in wasm exports");
        // This assertion doesn't hold when emscripten is run in --post-link
        // mode.
        // TODO(sbc): Read INITIAL_MEMORY out of the wasm file in post-link mode.
        //assert(wasmMemory.buffer.byteLength === 16777216);
        updateGlobalBufferAndViews(wasmMemory.buffer);

        wasmTable = Module["asm"]["__indirect_function_table"];
        assert(wasmTable, "table not found in wasm exports");

        addOnInit(Module["asm"]["__wasm_call_ctors"]);

        removeRunDependency("wasm-instantiate");
    }
    // we can't run yet (except in a pthread, where we have a custom sync instantiator)
    addRunDependency("wasm-instantiate");

    // Prefer streaming instantiation if available.
    // Async compilation can be confusing when an error on the page overwrites Module
    // (for example, if the order of elements is wrong, and the one defining Module is
    // later), so we save Module and check it later.
    var trueModule = Module;
    function receiveInstantiationResult(result) {
        // 'result' is a ResultObject object which has both the module and instance.
        // receiveInstance() will swap in the exports (to Module.asm) so they can be called
        assert(
            Module === trueModule,
            "the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?"
        );
        trueModule = null;
        // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line.
        // When the regression is fixed, can restore the above USE_PTHREADS-enabled path.
        receiveInstance(result["instance"]);
    }

    function instantiateArrayBuffer(receiver) {
        return getBinaryPromise()
            .then(function (binary) {
                return WebAssembly.instantiate(binary, info);
            })
            .then(function (instance) {
                return instance;
            })
            .then(receiver, function (reason) {
                err("failed to asynchronously prepare wasm: " + reason);

                // Warn on some common problems.
                if (isFileURI(wasmBinaryFile)) {
                    err(
                        "warning: Loading from a file URI (" +
                            wasmBinaryFile +
                            ") is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing"
                    );
                }
                abort(reason);
            });
    }

    function instantiateAsync() {
        if (
            !wasmBinary &&
            typeof WebAssembly.instantiateStreaming == "function" &&
            !isDataURI(wasmBinaryFile) &&
            typeof fetch == "function"
        ) {
            return fetch(wasmBinaryFile).then(function (response) {
                // Suppress closure warning here since the upstream definition for
                // instantiateStreaming only allows Promise<Repsponse> rather than
                // an actual Response.
                // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure is fixed.
                /** @suppress {checkTypes} */
                var result = WebAssembly.instantiateStreaming(response, info);

                return result.then(receiveInstantiationResult, function (reason) {
                    // We expect the most common failure cause to be a bad MIME type for the binary,
                    // in which case falling back to ArrayBuffer instantiation should work.
                    err("wasm streaming compile failed: " + reason);
                    err("falling back to ArrayBuffer instantiation");
                    return instantiateArrayBuffer(receiveInstantiationResult);
                });
            });
        } else {
            return instantiateArrayBuffer(receiveInstantiationResult);
        }
    }

    // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback
    // to manually instantiate the Wasm module themselves. This allows pages to run the instantiation parallel
    // to any other async startup actions they are performing.
    if (Module["instantiateWasm"]) {
        try {
            var exports = Module["instantiateWasm"](info, receiveInstance);
            return exports;
        } catch (e) {
            err("Module.instantiateWasm callback failed with error: " + e);
            return false;
        }
    }

    instantiateAsync();
    return {}; // no exports yet; we'll fill them in later
}

// Globals used by JS i64 conversions (see makeSetValue)
var tempDouble;
var tempI64;

// === Body ===

var ASM_CONSTS = {};

function callRuntimeCallbacks(callbacks) {
    while (callbacks.length > 0) {
        var callback = callbacks.shift();
        if (typeof callback == "function") {
            callback(Module); // Pass the module as the first argument.
            continue;
        }
        var func = callback.func;
        if (typeof func == "number") {
            if (callback.arg === undefined) {
                getWasmTableEntry(func)();
            } else {
                getWasmTableEntry(func)(callback.arg);
            }
        } else {
            func(callback.arg === undefined ? null : callback.arg);
        }
    }
}

function withStackSave(f) {
    var stack = stackSave();
    var ret = f();
    stackRestore(stack);
    return ret;
}
function demangle(func) {
    warnOnce("warning: build with  -s DEMANGLE_SUPPORT=1  to link in libcxxabi demangling");
    return func;
}

function demangleAll(text) {
    var regex = /\b_Z[\w\d_]+/g;
    return text.replace(regex, function (x) {
        var y = demangle(x);
        return x === y ? x : y + " [" + x + "]";
    });
}

var wasmTableMirror = [];
function getWasmTableEntry(funcPtr) {
    var func = wasmTableMirror[funcPtr];
    if (!func) {
        if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1;
        wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
    }
    assert(
        wasmTable.get(funcPtr) == func,
        "JavaScript-side Wasm function table mirror is out of date!"
    );
    return func;
}

function handleException(e) {
    // Certain exception types we do not treat as errors since they are used for
    // internal control flow.
    // 1. ExitStatus, which is thrown by exit()
    // 2. "unwind", which is thrown by emscripten_unwind_to_js_event_loop() and others
    //    that wish to return to JS event loop.
    if (e instanceof ExitStatus || e == "unwind") {
        return EXITSTATUS;
    }
    quit_(1, e);
}

function jsStackTrace() {
    var error = new Error();
    if (!error.stack) {
        // IE10+ special cases: It does have callstack info, but it is only populated if an Error object is thrown,
        // so try that as a special-case.
        try {
            throw new Error();
        } catch (e) {
            error = e;
        }
        if (!error.stack) {
            return "(no stack trace available)";
        }
    }
    return error.stack.toString();
}

function setWasmTableEntry(idx, func) {
    wasmTable.set(idx, func);
    wasmTableMirror[idx] = func;
}

function stackTrace() {
    var js = jsStackTrace();
    if (Module["extraStackTrace"]) js += "\n" + Module["extraStackTrace"]();
    return demangleAll(js);
}

function _emscripten_memcpy_big(dest, src, num) {
    HEAPU8.copyWithin(dest, src, src + num);
}

function _emscripten_get_heap_max() {
    return HEAPU8.length;
}

function abortOnCannotGrowMemory(requestedSize) {
    abort(
        "Cannot enlarge memory arrays to size " +
            requestedSize +
            " bytes (OOM). Either (1) compile with  -s INITIAL_MEMORY=X  with X higher than the current value " +
            HEAP8.length +
            ", (2) compile with  -s ALLOW_MEMORY_GROWTH=1  which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with  -s ABORTING_MALLOC=0 "
    );
}
function _emscripten_resize_heap(requestedSize) {
    var oldSize = HEAPU8.length;
    requestedSize = requestedSize >>> 0;
    abortOnCannotGrowMemory(requestedSize);
}

var SYSCALLS = {
    buffers: [null, [], []],
    printChar: function (stream, curr) {
        var buffer = SYSCALLS.buffers[stream];
        assert(buffer);
        if (curr === 0 || curr === 10) {
            (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
            buffer.length = 0;
        } else {
            buffer.push(curr);
        }
    },
    varargs: undefined,
    get: function () {
        assert(SYSCALLS.varargs != undefined);
        SYSCALLS.varargs += 4;
        var ret = HEAP32[(SYSCALLS.varargs - 4) >> 2];
        return ret;
    },
    getStr: function (ptr) {
        var ret = UTF8ToString(ptr);
        return ret;
    },
    get64: function (low, high) {
        if (low >= 0) assert(high === 0);
        else assert(high === -1);
        return low;
    },
};
function _fd_close(fd) {
    abort("it should not be possible to operate on streams when !SYSCALLS_REQUIRE_FILESYSTEM");
    return 0;
}

function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
    abort("it should not be possible to operate on streams when !SYSCALLS_REQUIRE_FILESYSTEM");
}

function flush_NO_FILESYSTEM() {
    // flush anything remaining in the buffers during shutdown
    ___stdio_exit();
    var buffers = SYSCALLS.buffers;
    if (buffers[1].length) SYSCALLS.printChar(1, 10);
    if (buffers[2].length) SYSCALLS.printChar(2, 10);
}
function _fd_write(fd, iov, iovcnt, pnum) {
    // hack to support printf in SYSCALLS_REQUIRE_FILESYSTEM=0
    var num = 0;
    for (var i = 0; i < iovcnt; i++) {
        var ptr = HEAP32[iov >> 2];
        var len = HEAP32[(iov + 4) >> 2];
        iov += 8;
        for (var j = 0; j < len; j++) {
            SYSCALLS.printChar(fd, HEAPU8[ptr + j]);
        }
        num += len;
    }
    HEAP32[pnum >> 2] = num;
    return 0;
}

function _setTempRet0(val) {
    setTempRet0(val);
}
var ASSERTIONS = true;

/** @type {function(string, boolean=, number=)} */
function intArrayFromString(stringy, dontAddNull, length) {
    var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
    var u8array = new Array(len);
    var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
    if (dontAddNull) u8array.length = numBytesWritten;
    return u8array;
}

function intArrayToString(array) {
    var ret = [];
    for (var i = 0; i < array.length; i++) {
        var chr = array[i];
        if (chr > 0xff) {
            if (ASSERTIONS) {
                assert(
                    false,
                    "Character code " +
                        chr +
                        " (" +
                        String.fromCharCode(chr) +
                        ")  at offset " +
                        i +
                        " not in 0x00-0xFF."
                );
            }
            chr &= 0xff;
        }
        ret.push(String.fromCharCode(chr));
    }
    return ret.join("");
}

var asmLibraryArg = {
    emscripten_memcpy_big: _emscripten_memcpy_big,
    emscripten_resize_heap: _emscripten_resize_heap,
    fd_close: _fd_close,
    fd_seek: _fd_seek,
    fd_write: _fd_write,
    setTempRet0: _setTempRet0,
};
var asm = createWasm();
/** @type {function(...*):?} */
var ___wasm_call_ctors = (Module["___wasm_call_ctors"] = createExportWrapper("__wasm_call_ctors"));

/** @type {function(...*):?} */
var _record_browser_info = (Module["_record_browser_info"] =
    createExportWrapper("record_browser_info"));

/** @type {function(...*):?} */
var _add_mouse_event = (Module["_add_mouse_event"] = createExportWrapper("add_mouse_event"));

/** @type {function(...*):?} */
var _get_code = (Module["_get_code"] = createExportWrapper("get_code"));

/** @type {function(...*):?} */
var ___errno_location = (Module["___errno_location"] = createExportWrapper("__errno_location"));

/** @type {function(...*):?} */
var ___stdio_exit = (Module["___stdio_exit"] = createExportWrapper("__stdio_exit"));

/** @type {function(...*):?} */
var _emscripten_stack_init = (Module["_emscripten_stack_init"] = function () {
    return (_emscripten_stack_init = Module["_emscripten_stack_init"] =
        Module["asm"]["emscripten_stack_init"]).apply(null, arguments);
});

/** @type {function(...*):?} */
var _emscripten_stack_get_free = (Module["_emscripten_stack_get_free"] = function () {
    return (_emscripten_stack_get_free = Module["_emscripten_stack_get_free"] =
        Module["asm"]["emscripten_stack_get_free"]).apply(null, arguments);
});

/** @type {function(...*):?} */
var _emscripten_stack_get_base = (Module["_emscripten_stack_get_base"] = function () {
    return (_emscripten_stack_get_base = Module["_emscripten_stack_get_base"] =
        Module["asm"]["emscripten_stack_get_base"]).apply(null, arguments);
});

/** @type {function(...*):?} */
var _emscripten_stack_get_end = (Module["_emscripten_stack_get_end"] = function () {
    return (_emscripten_stack_get_end = Module["_emscripten_stack_get_end"] =
        Module["asm"]["emscripten_stack_get_end"]).apply(null, arguments);
});

/** @type {function(...*):?} */
var stackSave = (Module["stackSave"] = createExportWrapper("stackSave"));

/** @type {function(...*):?} */
var stackRestore = (Module["stackRestore"] = createExportWrapper("stackRestore"));

/** @type {function(...*):?} */
var stackAlloc = (Module["stackAlloc"] = createExportWrapper("stackAlloc"));

/** @type {function(...*):?} */
var dynCall_jiji = (Module["dynCall_jiji"] = createExportWrapper("dynCall_jiji"));

// === Auto-generated postamble setup entry stuff ===

if (!Object.getOwnPropertyDescriptor(Module, "intArrayFromString"))
    Module["intArrayFromString"] = () =>
        abort(
            "'intArrayFromString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "intArrayToString"))
    Module["intArrayToString"] = () =>
        abort(
            "'intArrayToString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
Module["ccall"] = ccall;
Module["cwrap"] = cwrap;
if (!Object.getOwnPropertyDescriptor(Module, "setValue"))
    Module["setValue"] = () =>
        abort("'setValue' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "getValue"))
    Module["getValue"] = () =>
        abort("'getValue' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "allocate"))
    Module["allocate"] = () =>
        abort("'allocate' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "UTF8ArrayToString"))
    Module["UTF8ArrayToString"] = () =>
        abort(
            "'UTF8ArrayToString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "UTF8ToString"))
    Module["UTF8ToString"] = () =>
        abort("'UTF8ToString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF8Array"))
    Module["stringToUTF8Array"] = () =>
        abort(
            "'stringToUTF8Array' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF8"))
    Module["stringToUTF8"] = () =>
        abort("'stringToUTF8' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF8"))
    Module["lengthBytesUTF8"] = () =>
        abort(
            "'lengthBytesUTF8' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "stackTrace"))
    Module["stackTrace"] = () =>
        abort("'stackTrace' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "addOnPreRun"))
    Module["addOnPreRun"] = () =>
        abort("'addOnPreRun' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "addOnInit"))
    Module["addOnInit"] = () =>
        abort("'addOnInit' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "addOnPreMain"))
    Module["addOnPreMain"] = () =>
        abort("'addOnPreMain' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "addOnExit"))
    Module["addOnExit"] = () =>
        abort("'addOnExit' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "addOnPostRun"))
    Module["addOnPostRun"] = () =>
        abort("'addOnPostRun' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "writeStringToMemory"))
    Module["writeStringToMemory"] = () =>
        abort(
            "'writeStringToMemory' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "writeArrayToMemory"))
    Module["writeArrayToMemory"] = () =>
        abort(
            "'writeArrayToMemory' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "writeAsciiToMemory"))
    Module["writeAsciiToMemory"] = () =>
        abort(
            "'writeAsciiToMemory' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "addRunDependency"))
    Module["addRunDependency"] = () =>
        abort(
            "'addRunDependency' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"
        );
if (!Object.getOwnPropertyDescriptor(Module, "removeRunDependency"))
    Module["removeRunDependency"] = () =>
        abort(
            "'removeRunDependency' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"
        );
if (!Object.getOwnPropertyDescriptor(Module, "FS_createFolder"))
    Module["FS_createFolder"] = () =>
        abort(
            "'FS_createFolder' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "FS_createPath"))
    Module["FS_createPath"] = () =>
        abort(
            "'FS_createPath' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"
        );
if (!Object.getOwnPropertyDescriptor(Module, "FS_createDataFile"))
    Module["FS_createDataFile"] = () =>
        abort(
            "'FS_createDataFile' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"
        );
if (!Object.getOwnPropertyDescriptor(Module, "FS_createPreloadedFile"))
    Module["FS_createPreloadedFile"] = () =>
        abort(
            "'FS_createPreloadedFile' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"
        );
if (!Object.getOwnPropertyDescriptor(Module, "FS_createLazyFile"))
    Module["FS_createLazyFile"] = () =>
        abort(
            "'FS_createLazyFile' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"
        );
if (!Object.getOwnPropertyDescriptor(Module, "FS_createLink"))
    Module["FS_createLink"] = () =>
        abort("'FS_createLink' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "FS_createDevice"))
    Module["FS_createDevice"] = () =>
        abort(
            "'FS_createDevice' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"
        );
if (!Object.getOwnPropertyDescriptor(Module, "FS_unlink"))
    Module["FS_unlink"] = () =>
        abort(
            "'FS_unlink' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"
        );
if (!Object.getOwnPropertyDescriptor(Module, "getLEB"))
    Module["getLEB"] = () =>
        abort("'getLEB' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "getFunctionTables"))
    Module["getFunctionTables"] = () =>
        abort(
            "'getFunctionTables' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "alignFunctionTables"))
    Module["alignFunctionTables"] = () =>
        abort(
            "'alignFunctionTables' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "registerFunctions"))
    Module["registerFunctions"] = () =>
        abort(
            "'registerFunctions' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "addFunction"))
    Module["addFunction"] = () =>
        abort("'addFunction' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "removeFunction"))
    Module["removeFunction"] = () =>
        abort(
            "'removeFunction' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "getFuncWrapper"))
    Module["getFuncWrapper"] = () =>
        abort(
            "'getFuncWrapper' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "prettyPrint"))
    Module["prettyPrint"] = () =>
        abort("'prettyPrint' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "dynCall"))
    Module["dynCall"] = () =>
        abort("'dynCall' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "getCompilerSetting"))
    Module["getCompilerSetting"] = () =>
        abort(
            "'getCompilerSetting' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "print"))
    Module["print"] = () =>
        abort("'print' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "printErr"))
    Module["printErr"] = () =>
        abort("'printErr' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "getTempRet0"))
    Module["getTempRet0"] = () =>
        abort("'getTempRet0' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "setTempRet0"))
    Module["setTempRet0"] = () =>
        abort("'setTempRet0' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "callMain"))
    Module["callMain"] = () =>
        abort("'callMain' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "abort"))
    Module["abort"] = () =>
        abort("'abort' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "keepRuntimeAlive"))
    Module["keepRuntimeAlive"] = () =>
        abort(
            "'keepRuntimeAlive' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "zeroMemory"))
    Module["zeroMemory"] = () =>
        abort("'zeroMemory' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "stringToNewUTF8"))
    Module["stringToNewUTF8"] = () =>
        abort(
            "'stringToNewUTF8' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "abortOnCannotGrowMemory"))
    Module["abortOnCannotGrowMemory"] = () =>
        abort(
            "'abortOnCannotGrowMemory' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "emscripten_realloc_buffer"))
    Module["emscripten_realloc_buffer"] = () =>
        abort(
            "'emscripten_realloc_buffer' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "ENV"))
    Module["ENV"] = () =>
        abort("'ENV' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "withStackSave"))
    Module["withStackSave"] = () =>
        abort("'withStackSave' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "ERRNO_CODES"))
    Module["ERRNO_CODES"] = () =>
        abort("'ERRNO_CODES' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "ERRNO_MESSAGES"))
    Module["ERRNO_MESSAGES"] = () =>
        abort(
            "'ERRNO_MESSAGES' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "setErrNo"))
    Module["setErrNo"] = () =>
        abort("'setErrNo' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "inetPton4"))
    Module["inetPton4"] = () =>
        abort("'inetPton4' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "inetNtop4"))
    Module["inetNtop4"] = () =>
        abort("'inetNtop4' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "inetPton6"))
    Module["inetPton6"] = () =>
        abort("'inetPton6' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "inetNtop6"))
    Module["inetNtop6"] = () =>
        abort("'inetNtop6' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "readSockaddr"))
    Module["readSockaddr"] = () =>
        abort("'readSockaddr' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "writeSockaddr"))
    Module["writeSockaddr"] = () =>
        abort("'writeSockaddr' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "DNS"))
    Module["DNS"] = () =>
        abort("'DNS' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "getHostByName"))
    Module["getHostByName"] = () =>
        abort("'getHostByName' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "Protocols"))
    Module["Protocols"] = () =>
        abort("'Protocols' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "Sockets"))
    Module["Sockets"] = () =>
        abort("'Sockets' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "getRandomDevice"))
    Module["getRandomDevice"] = () =>
        abort(
            "'getRandomDevice' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "traverseStack"))
    Module["traverseStack"] = () =>
        abort("'traverseStack' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "convertFrameToPC"))
    Module["convertFrameToPC"] = () =>
        abort(
            "'convertFrameToPC' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "UNWIND_CACHE"))
    Module["UNWIND_CACHE"] = () =>
        abort("'UNWIND_CACHE' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "saveInUnwindCache"))
    Module["saveInUnwindCache"] = () =>
        abort(
            "'saveInUnwindCache' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "convertPCtoSourceLocation"))
    Module["convertPCtoSourceLocation"] = () =>
        abort(
            "'convertPCtoSourceLocation' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "readAsmConstArgsArray"))
    Module["readAsmConstArgsArray"] = () =>
        abort(
            "'readAsmConstArgsArray' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "readAsmConstArgs"))
    Module["readAsmConstArgs"] = () =>
        abort(
            "'readAsmConstArgs' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "mainThreadEM_ASM"))
    Module["mainThreadEM_ASM"] = () =>
        abort(
            "'mainThreadEM_ASM' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "jstoi_q"))
    Module["jstoi_q"] = () =>
        abort("'jstoi_q' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "jstoi_s"))
    Module["jstoi_s"] = () =>
        abort("'jstoi_s' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "getExecutableName"))
    Module["getExecutableName"] = () =>
        abort(
            "'getExecutableName' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "listenOnce"))
    Module["listenOnce"] = () =>
        abort("'listenOnce' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "autoResumeAudioContext"))
    Module["autoResumeAudioContext"] = () =>
        abort(
            "'autoResumeAudioContext' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "dynCallLegacy"))
    Module["dynCallLegacy"] = () =>
        abort("'dynCallLegacy' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "getDynCaller"))
    Module["getDynCaller"] = () =>
        abort("'getDynCaller' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "dynCall"))
    Module["dynCall"] = () =>
        abort("'dynCall' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "callRuntimeCallbacks"))
    Module["callRuntimeCallbacks"] = () =>
        abort(
            "'callRuntimeCallbacks' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "wasmTableMirror"))
    Module["wasmTableMirror"] = () =>
        abort(
            "'wasmTableMirror' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "setWasmTableEntry"))
    Module["setWasmTableEntry"] = () =>
        abort(
            "'setWasmTableEntry' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "getWasmTableEntry"))
    Module["getWasmTableEntry"] = () =>
        abort(
            "'getWasmTableEntry' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "handleException"))
    Module["handleException"] = () =>
        abort(
            "'handleException' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "runtimeKeepalivePush"))
    Module["runtimeKeepalivePush"] = () =>
        abort(
            "'runtimeKeepalivePush' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "runtimeKeepalivePop"))
    Module["runtimeKeepalivePop"] = () =>
        abort(
            "'runtimeKeepalivePop' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "callUserCallback"))
    Module["callUserCallback"] = () =>
        abort(
            "'callUserCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "maybeExit"))
    Module["maybeExit"] = () =>
        abort("'maybeExit' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "safeSetTimeout"))
    Module["safeSetTimeout"] = () =>
        abort(
            "'safeSetTimeout' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "asmjsMangle"))
    Module["asmjsMangle"] = () =>
        abort("'asmjsMangle' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "asyncLoad"))
    Module["asyncLoad"] = () =>
        abort("'asyncLoad' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "alignMemory"))
    Module["alignMemory"] = () =>
        abort("'alignMemory' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "mmapAlloc"))
    Module["mmapAlloc"] = () =>
        abort("'mmapAlloc' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "reallyNegative"))
    Module["reallyNegative"] = () =>
        abort(
            "'reallyNegative' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "unSign"))
    Module["unSign"] = () =>
        abort("'unSign' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "reSign"))
    Module["reSign"] = () =>
        abort("'reSign' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "formatString"))
    Module["formatString"] = () =>
        abort("'formatString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "PATH"))
    Module["PATH"] = () =>
        abort("'PATH' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "PATH_FS"))
    Module["PATH_FS"] = () =>
        abort("'PATH_FS' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "SYSCALLS"))
    Module["SYSCALLS"] = () =>
        abort("'SYSCALLS' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "getSocketFromFD"))
    Module["getSocketFromFD"] = () =>
        abort(
            "'getSocketFromFD' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "getSocketAddress"))
    Module["getSocketAddress"] = () =>
        abort(
            "'getSocketAddress' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "JSEvents"))
    Module["JSEvents"] = () =>
        abort("'JSEvents' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "registerKeyEventCallback"))
    Module["registerKeyEventCallback"] = () =>
        abort(
            "'registerKeyEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "specialHTMLTargets"))
    Module["specialHTMLTargets"] = () =>
        abort(
            "'specialHTMLTargets' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "maybeCStringToJsString"))
    Module["maybeCStringToJsString"] = () =>
        abort(
            "'maybeCStringToJsString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "findEventTarget"))
    Module["findEventTarget"] = () =>
        abort(
            "'findEventTarget' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "findCanvasEventTarget"))
    Module["findCanvasEventTarget"] = () =>
        abort(
            "'findCanvasEventTarget' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "getBoundingClientRect"))
    Module["getBoundingClientRect"] = () =>
        abort(
            "'getBoundingClientRect' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "fillMouseEventData"))
    Module["fillMouseEventData"] = () =>
        abort(
            "'fillMouseEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "registerMouseEventCallback"))
    Module["registerMouseEventCallback"] = () =>
        abort(
            "'registerMouseEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "registerWheelEventCallback"))
    Module["registerWheelEventCallback"] = () =>
        abort(
            "'registerWheelEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "registerUiEventCallback"))
    Module["registerUiEventCallback"] = () =>
        abort(
            "'registerUiEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "registerFocusEventCallback"))
    Module["registerFocusEventCallback"] = () =>
        abort(
            "'registerFocusEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "fillDeviceOrientationEventData"))
    Module["fillDeviceOrientationEventData"] = () =>
        abort(
            "'fillDeviceOrientationEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "registerDeviceOrientationEventCallback"))
    Module["registerDeviceOrientationEventCallback"] = () =>
        abort(
            "'registerDeviceOrientationEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "fillDeviceMotionEventData"))
    Module["fillDeviceMotionEventData"] = () =>
        abort(
            "'fillDeviceMotionEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "registerDeviceMotionEventCallback"))
    Module["registerDeviceMotionEventCallback"] = () =>
        abort(
            "'registerDeviceMotionEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "screenOrientation"))
    Module["screenOrientation"] = () =>
        abort(
            "'screenOrientation' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "fillOrientationChangeEventData"))
    Module["fillOrientationChangeEventData"] = () =>
        abort(
            "'fillOrientationChangeEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "registerOrientationChangeEventCallback"))
    Module["registerOrientationChangeEventCallback"] = () =>
        abort(
            "'registerOrientationChangeEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "fillFullscreenChangeEventData"))
    Module["fillFullscreenChangeEventData"] = () =>
        abort(
            "'fillFullscreenChangeEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "registerFullscreenChangeEventCallback"))
    Module["registerFullscreenChangeEventCallback"] = () =>
        abort(
            "'registerFullscreenChangeEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "registerRestoreOldStyle"))
    Module["registerRestoreOldStyle"] = () =>
        abort(
            "'registerRestoreOldStyle' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "hideEverythingExceptGivenElement"))
    Module["hideEverythingExceptGivenElement"] = () =>
        abort(
            "'hideEverythingExceptGivenElement' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "restoreHiddenElements"))
    Module["restoreHiddenElements"] = () =>
        abort(
            "'restoreHiddenElements' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "setLetterbox"))
    Module["setLetterbox"] = () =>
        abort("'setLetterbox' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "currentFullscreenStrategy"))
    Module["currentFullscreenStrategy"] = () =>
        abort(
            "'currentFullscreenStrategy' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "restoreOldWindowedStyle"))
    Module["restoreOldWindowedStyle"] = () =>
        abort(
            "'restoreOldWindowedStyle' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "softFullscreenResizeWebGLRenderTarget"))
    Module["softFullscreenResizeWebGLRenderTarget"] = () =>
        abort(
            "'softFullscreenResizeWebGLRenderTarget' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "doRequestFullscreen"))
    Module["doRequestFullscreen"] = () =>
        abort(
            "'doRequestFullscreen' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "fillPointerlockChangeEventData"))
    Module["fillPointerlockChangeEventData"] = () =>
        abort(
            "'fillPointerlockChangeEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "registerPointerlockChangeEventCallback"))
    Module["registerPointerlockChangeEventCallback"] = () =>
        abort(
            "'registerPointerlockChangeEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "registerPointerlockErrorEventCallback"))
    Module["registerPointerlockErrorEventCallback"] = () =>
        abort(
            "'registerPointerlockErrorEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "requestPointerLock"))
    Module["requestPointerLock"] = () =>
        abort(
            "'requestPointerLock' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "fillVisibilityChangeEventData"))
    Module["fillVisibilityChangeEventData"] = () =>
        abort(
            "'fillVisibilityChangeEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "registerVisibilityChangeEventCallback"))
    Module["registerVisibilityChangeEventCallback"] = () =>
        abort(
            "'registerVisibilityChangeEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "registerTouchEventCallback"))
    Module["registerTouchEventCallback"] = () =>
        abort(
            "'registerTouchEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "fillGamepadEventData"))
    Module["fillGamepadEventData"] = () =>
        abort(
            "'fillGamepadEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "registerGamepadEventCallback"))
    Module["registerGamepadEventCallback"] = () =>
        abort(
            "'registerGamepadEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "registerBeforeUnloadEventCallback"))
    Module["registerBeforeUnloadEventCallback"] = () =>
        abort(
            "'registerBeforeUnloadEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "fillBatteryEventData"))
    Module["fillBatteryEventData"] = () =>
        abort(
            "'fillBatteryEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "battery"))
    Module["battery"] = () =>
        abort("'battery' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "registerBatteryEventCallback"))
    Module["registerBatteryEventCallback"] = () =>
        abort(
            "'registerBatteryEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "setCanvasElementSize"))
    Module["setCanvasElementSize"] = () =>
        abort(
            "'setCanvasElementSize' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "getCanvasElementSize"))
    Module["getCanvasElementSize"] = () =>
        abort(
            "'getCanvasElementSize' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "demangle"))
    Module["demangle"] = () =>
        abort("'demangle' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "demangleAll"))
    Module["demangleAll"] = () =>
        abort("'demangleAll' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "jsStackTrace"))
    Module["jsStackTrace"] = () =>
        abort("'jsStackTrace' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "stackTrace"))
    Module["stackTrace"] = () =>
        abort("'stackTrace' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "getEnvStrings"))
    Module["getEnvStrings"] = () =>
        abort("'getEnvStrings' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "checkWasiClock"))
    Module["checkWasiClock"] = () =>
        abort(
            "'checkWasiClock' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "flush_NO_FILESYSTEM"))
    Module["flush_NO_FILESYSTEM"] = () =>
        abort(
            "'flush_NO_FILESYSTEM' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToI64"))
    Module["writeI53ToI64"] = () =>
        abort("'writeI53ToI64' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToI64Clamped"))
    Module["writeI53ToI64Clamped"] = () =>
        abort(
            "'writeI53ToI64Clamped' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToI64Signaling"))
    Module["writeI53ToI64Signaling"] = () =>
        abort(
            "'writeI53ToI64Signaling' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToU64Clamped"))
    Module["writeI53ToU64Clamped"] = () =>
        abort(
            "'writeI53ToU64Clamped' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToU64Signaling"))
    Module["writeI53ToU64Signaling"] = () =>
        abort(
            "'writeI53ToU64Signaling' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "readI53FromI64"))
    Module["readI53FromI64"] = () =>
        abort(
            "'readI53FromI64' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "readI53FromU64"))
    Module["readI53FromU64"] = () =>
        abort(
            "'readI53FromU64' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "convertI32PairToI53"))
    Module["convertI32PairToI53"] = () =>
        abort(
            "'convertI32PairToI53' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "convertU32PairToI53"))
    Module["convertU32PairToI53"] = () =>
        abort(
            "'convertU32PairToI53' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "setImmediateWrapped"))
    Module["setImmediateWrapped"] = () =>
        abort(
            "'setImmediateWrapped' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "clearImmediateWrapped"))
    Module["clearImmediateWrapped"] = () =>
        abort(
            "'clearImmediateWrapped' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "polyfillSetImmediate"))
    Module["polyfillSetImmediate"] = () =>
        abort(
            "'polyfillSetImmediate' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "uncaughtExceptionCount"))
    Module["uncaughtExceptionCount"] = () =>
        abort(
            "'uncaughtExceptionCount' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "exceptionLast"))
    Module["exceptionLast"] = () =>
        abort("'exceptionLast' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "exceptionCaught"))
    Module["exceptionCaught"] = () =>
        abort(
            "'exceptionCaught' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "ExceptionInfo"))
    Module["ExceptionInfo"] = () =>
        abort("'ExceptionInfo' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "CatchInfo"))
    Module["CatchInfo"] = () =>
        abort("'CatchInfo' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "exception_addRef"))
    Module["exception_addRef"] = () =>
        abort(
            "'exception_addRef' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "exception_decRef"))
    Module["exception_decRef"] = () =>
        abort(
            "'exception_decRef' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "Browser"))
    Module["Browser"] = () =>
        abort("'Browser' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "funcWrappers"))
    Module["funcWrappers"] = () =>
        abort("'funcWrappers' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "getFuncWrapper"))
    Module["getFuncWrapper"] = () =>
        abort(
            "'getFuncWrapper' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "setMainLoop"))
    Module["setMainLoop"] = () =>
        abort("'setMainLoop' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "wget"))
    Module["wget"] = () =>
        abort("'wget' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "FS"))
    Module["FS"] = () =>
        abort("'FS' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "MEMFS"))
    Module["MEMFS"] = () =>
        abort("'MEMFS' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "TTY"))
    Module["TTY"] = () =>
        abort("'TTY' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "PIPEFS"))
    Module["PIPEFS"] = () =>
        abort("'PIPEFS' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "SOCKFS"))
    Module["SOCKFS"] = () =>
        abort("'SOCKFS' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "_setNetworkCallback"))
    Module["_setNetworkCallback"] = () =>
        abort(
            "'_setNetworkCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "tempFixedLengthArray"))
    Module["tempFixedLengthArray"] = () =>
        abort(
            "'tempFixedLengthArray' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "miniTempWebGLFloatBuffers"))
    Module["miniTempWebGLFloatBuffers"] = () =>
        abort(
            "'miniTempWebGLFloatBuffers' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "heapObjectForWebGLType"))
    Module["heapObjectForWebGLType"] = () =>
        abort(
            "'heapObjectForWebGLType' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "heapAccessShiftForWebGLHeap"))
    Module["heapAccessShiftForWebGLHeap"] = () =>
        abort(
            "'heapAccessShiftForWebGLHeap' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "GL"))
    Module["GL"] = () =>
        abort("'GL' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGet"))
    Module["emscriptenWebGLGet"] = () =>
        abort(
            "'emscriptenWebGLGet' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "computeUnpackAlignedImageSize"))
    Module["computeUnpackAlignedImageSize"] = () =>
        abort(
            "'computeUnpackAlignedImageSize' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGetTexPixelData"))
    Module["emscriptenWebGLGetTexPixelData"] = () =>
        abort(
            "'emscriptenWebGLGetTexPixelData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGetUniform"))
    Module["emscriptenWebGLGetUniform"] = () =>
        abort(
            "'emscriptenWebGLGetUniform' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "webglGetUniformLocation"))
    Module["webglGetUniformLocation"] = () =>
        abort(
            "'webglGetUniformLocation' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "webglPrepareUniformLocationsBeforeFirstUse"))
    Module["webglPrepareUniformLocationsBeforeFirstUse"] = () =>
        abort(
            "'webglPrepareUniformLocationsBeforeFirstUse' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "webglGetLeftBracePos"))
    Module["webglGetLeftBracePos"] = () =>
        abort(
            "'webglGetLeftBracePos' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGetVertexAttrib"))
    Module["emscriptenWebGLGetVertexAttrib"] = () =>
        abort(
            "'emscriptenWebGLGetVertexAttrib' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "writeGLArray"))
    Module["writeGLArray"] = () =>
        abort("'writeGLArray' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "AL"))
    Module["AL"] = () =>
        abort("'AL' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "SDL_unicode"))
    Module["SDL_unicode"] = () =>
        abort("'SDL_unicode' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "SDL_ttfContext"))
    Module["SDL_ttfContext"] = () =>
        abort(
            "'SDL_ttfContext' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "SDL_audio"))
    Module["SDL_audio"] = () =>
        abort("'SDL_audio' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "SDL"))
    Module["SDL"] = () =>
        abort("'SDL' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "SDL_gfx"))
    Module["SDL_gfx"] = () =>
        abort("'SDL_gfx' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "GLUT"))
    Module["GLUT"] = () =>
        abort("'GLUT' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "EGL"))
    Module["EGL"] = () =>
        abort("'EGL' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "GLFW_Window"))
    Module["GLFW_Window"] = () =>
        abort("'GLFW_Window' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "GLFW"))
    Module["GLFW"] = () =>
        abort("'GLFW' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "GLEW"))
    Module["GLEW"] = () =>
        abort("'GLEW' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "IDBStore"))
    Module["IDBStore"] = () =>
        abort("'IDBStore' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "runAndAbortIfError"))
    Module["runAndAbortIfError"] = () =>
        abort(
            "'runAndAbortIfError' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "warnOnce"))
    Module["warnOnce"] = () =>
        abort("'warnOnce' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "stackSave"))
    Module["stackSave"] = () =>
        abort("'stackSave' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "stackRestore"))
    Module["stackRestore"] = () =>
        abort("'stackRestore' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "stackAlloc"))
    Module["stackAlloc"] = () =>
        abort("'stackAlloc' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "AsciiToString"))
    Module["AsciiToString"] = () =>
        abort("'AsciiToString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "stringToAscii"))
    Module["stringToAscii"] = () =>
        abort("'stringToAscii' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "UTF16ToString"))
    Module["UTF16ToString"] = () =>
        abort("'UTF16ToString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF16"))
    Module["stringToUTF16"] = () =>
        abort("'stringToUTF16' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF16"))
    Module["lengthBytesUTF16"] = () =>
        abort(
            "'lengthBytesUTF16' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "UTF32ToString"))
    Module["UTF32ToString"] = () =>
        abort("'UTF32ToString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF32"))
    Module["stringToUTF32"] = () =>
        abort("'stringToUTF32' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF32"))
    Module["lengthBytesUTF32"] = () =>
        abort(
            "'lengthBytesUTF32' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
if (!Object.getOwnPropertyDescriptor(Module, "allocateUTF8"))
    Module["allocateUTF8"] = () =>
        abort("'allocateUTF8' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
if (!Object.getOwnPropertyDescriptor(Module, "allocateUTF8OnStack"))
    Module["allocateUTF8OnStack"] = () =>
        abort(
            "'allocateUTF8OnStack' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
        );
Module["writeStackCookie"] = writeStackCookie;
Module["checkStackCookie"] = checkStackCookie;
if (!Object.getOwnPropertyDescriptor(Module, "ALLOC_NORMAL"))
    Object.defineProperty(Module, "ALLOC_NORMAL", {
        configurable: true,
        get: function () {
            abort(
                "'ALLOC_NORMAL' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
            );
        },
    });
if (!Object.getOwnPropertyDescriptor(Module, "ALLOC_STACK"))
    Object.defineProperty(Module, "ALLOC_STACK", {
        configurable: true,
        get: function () {
            abort(
                "'ALLOC_STACK' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"
            );
        },
    });

var calledRun;

/**
 * @constructor
 * @this {ExitStatus}
 */
function ExitStatus(status) {
    this.name = "ExitStatus";
    this.message = "Program terminated with exit(" + status + ")";
    this.status = status;
}

var calledMain = false;

dependenciesFulfilled = function runCaller() {
    // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
    if (!calledRun) run();
    if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
};

function stackCheckInit() {
    // This is normally called automatically during __wasm_call_ctors but need to
    // get these values before even running any of the ctors so we call it redundantly
    // here.
    // TODO(sbc): Move writeStackCookie to native to to avoid this.
    _emscripten_stack_init();
    writeStackCookie();
}

/** @type {function(Array=)} */
function run(args) {
    args = args || arguments_;

    if (runDependencies > 0) {
        return;
    }

    stackCheckInit();

    preRun();

    // a preRun added a dependency, run will be called later
    if (runDependencies > 0) {
        return;
    }

    function doRun() {
        // run may have just been called through dependencies being fulfilled just in this very frame,
        // or while the async setStatus time below was happening
        if (calledRun) return;
        calledRun = true;
        Module["calledRun"] = true;

        if (ABORT) return;

        initRuntime();

        if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();

        assert(
            !Module["_main"],
            'compiled without a main, but one is present. if you added it from JS, use Module["onRuntimeInitialized"]'
        );

        postRun();
    }

    if (Module["setStatus"]) {
        Module["setStatus"]("Running...");
        setTimeout(function () {
            setTimeout(function () {
                Module["setStatus"]("");
            }, 1);
            doRun();
        }, 1);
    } else {
        doRun();
    }
    checkStackCookie();
}
Module["run"] = run;

function checkUnflushedContent() {
    // Compiler settings do not allow exiting the runtime, so flushing
    // the streams is not possible. but in ASSERTIONS mode we check
    // if there was something to flush, and if so tell the user they
    // should request that the runtime be exitable.
    // Normally we would not even include flush() at all, but in ASSERTIONS
    // builds we do so just for this check, and here we see if there is any
    // content to flush, that is, we check if there would have been
    // something a non-ASSERTIONS build would have not seen.
    // How we flush the streams depends on whether we are in SYSCALLS_REQUIRE_FILESYSTEM=0
    // mode (which has its own special function for this; otherwise, all
    // the code is inside libc)
    var oldOut = out;
    var oldErr = err;
    var has = false;
    out = err = (x) => {
        has = true;
    };
    try {
        // it doesn't matter if it fails
        var flush = flush_NO_FILESYSTEM;
        if (flush) flush();
    } catch (e) {}
    out = oldOut;
    err = oldErr;
    if (has) {
        warnOnce(
            "stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the FAQ), or make sure to emit a newline when you printf etc."
        );
        warnOnce(
            "(this may also be due to not including full filesystem support - try building with -s FORCE_FILESYSTEM=1)"
        );
    }
}

/** @param {boolean|number=} implicit */
function exit(status, implicit) {
    EXITSTATUS = status;

    // Skip this check if the runtime is being kept alive deliberately.
    // For example if `exit_with_live_runtime` is called.
    if (!runtimeKeepaliveCounter) {
        checkUnflushedContent();
    }

    if (keepRuntimeAlive()) {
        // if exit() was called, we may warn the user if the runtime isn't actually being shut down
        if (!implicit) {
            var msg =
                "program exited (with status: " +
                status +
                "), but EXIT_RUNTIME is not set, so halting execution but not exiting the runtime or preventing further async execution (build with EXIT_RUNTIME=1, if you want a true shutdown)";
            err(msg);
        }
    } else {
        exitRuntime();
    }

    procExit(status);
}

function procExit(code) {
    EXITSTATUS = code;
    if (!keepRuntimeAlive()) {
        if (Module["onExit"]) Module["onExit"](code);
        ABORT = true;
    }
    quit_(code, new ExitStatus(code));
}

if (Module["preInit"]) {
    if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]];
    while (Module["preInit"].length > 0) {
        Module["preInit"].pop()();
    }
}

run();

Module.onRuntimeInitialized = async () => {
    window.leshemModule = Module;
};
